import Vue from 'vue'
import Vuex from 'vuex'
import { wxMiniLogin, getUserInfo } from '@/api/auth'

Vue.use(Vuex)

// 创建一个简单的 Vuex store
export default new Vuex.Store({
  state: {
    token: uni.getStorageSync('token') || '',
    userInfo: (() => {
      const userInfoStr = uni.getStorageSync('userInfo')
      if (!userInfoStr) return null
      try {
        return typeof userInfoStr === 'string' ? JSON.parse(userInfoStr) : userInfoStr
      } catch (e) {
        console.error('解析用户信息失败:', e)
        return null
      }
    })(),
    isLogin: !!uni.getStorageSync('token')
  },
  
  mutations: {
    SET_TOKEN(state, token) {
      console.log('SET_TOKEN mutation被调用，token长度:', token?.length || 0);
      state.token = token
      uni.setStorageSync('token', token)
      
      // 验证token是否已保存
      setTimeout(() => {
        const savedToken = uni.getStorageSync('token');
        if (!savedToken) {
          console.error('Token保存失败，再次尝试保存');
          uni.setStorageSync('token', token);
        } else {
          console.log('Token成功保存到storage');
        }
      }, 100);
    },
    
    SET_USER_INFO(state, userInfo) {
      state.userInfo = userInfo
      state.isLogin = true
      uni.setStorageSync('userInfo', JSON.stringify(userInfo))
    },
    
    CLEAR_AUTH(state) {
      state.token = ''
      state.userInfo = null
      state.isLogin = false
      uni.removeStorageSync('token')
      uni.removeStorageSync('userInfo')
    }
  },
  
  actions: {
    async wxLogin({ commit, dispatch }) {
      try {
        console.log('尝试微信静默登录')
        
        // 清除旧的登录状态
        commit('CLEAR_AUTH')
        
        // 获取微信登录code
        const loginResult = await new Promise((resolve, reject) => {
          uni.login({
            success: (res) => resolve(res),
            fail: (err) => reject(err)
          })
        })
        
        if (!loginResult.code) {
          throw new Error('获取微信code失败')
        }
        
        const code = loginResult.code
        console.log('获取到微信code:', code.substring(0, 6) + '...')
        
        // 确保异步调用，给一点时间间隔
        await new Promise(resolve => setTimeout(resolve, 100))
        
        // 调用后端登录接口
        console.log('调用wxMiniLogin, 传递code字符串')
        const res = await wxMiniLogin({ code })
        
        // 检查响应格式
        if (!res || !res.data) {
          console.error('登录响应格式不正确:', res)
          throw new Error('登录响应格式不正确')
        }
        
        // 根据响应数据结构获取token
        // 如果data字段本身就是token字符串
        let token = null
        if (typeof res.data === 'string') {
          token = res.data
        } else if (res.data.token) {
          // 如果token是data对象的属性
          token = res.data.token
        }
        
        if (!token) {
          console.error('无法从响应中获取token:', res.data)
          throw new Error('无法从响应中获取token')
        }
        
        console.log('登录成功, 获取到token:', token.substring(0, 8) + '...')
        
        // 保存token
        commit('SET_TOKEN', token)
        
        // 额外检查：确保token确实被保存
        if (token) {
          console.log('手动确保token保存到storage')
          uni.setStorageSync('token', token)
          
          // 验证token是否正确保存
          setTimeout(() => {
            const storedToken = uni.getStorageSync('token');
            if (!storedToken) {
              console.error('危险：登录成功但token未被保存到storage');
            } else if (storedToken !== token) {
              console.error('危险：存储的token与提供的token不匹配');
            } else {
              console.log('验证通过：token已正确保存到storage');
            }
          }, 100);
        }
        
        // 获取用户信息
        try {
          await dispatch('fetchUserInfo')
        } catch (error) {
          console.error('自动登录获取用户信息失败:', error)
          // 即使获取用户信息失败，只要有token就认为登录成功
        }
        
        console.log('微信静默登录成功')
        return true
      } catch (error) {
        console.error('微信登录失败:', error.message || error)
        return false
      }
    },
    
    async fetchUserInfo({ commit }) {
      try {
        console.log('开始获取用户信息...')
        // 先检查token是否存在
        const token = uni.getStorageSync('token');
        if (!token) {
          console.error('获取用户信息时发现token不存在');
          throw new Error('获取用户信息时token不存在');
        }
        
        console.log('准备请求用户信息，使用token:', token.substring(0, 8) + '...');
        const res = await getUserInfo()
        console.log('获取用户信息成功:', res)
        
        // 确保res.data存在
        if (!res.data) {
          throw new Error('获取用户信息成功但数据为空')
        }
        
        commit('SET_USER_INFO', res.data)
        return res.data
      } catch (error) {
        console.error('获取用户信息失败:', error.message || error)
        if (error.response) {
          console.log('错误状态码:', error.response.status)
          console.log('错误详情:', error.response.data)
        }
        commit('CLEAR_AUTH')
        throw error
      }
    },
    
    clearAuth({ commit }) {
      console.log('清除认证信息')
      
      // 在vuex中清除
      commit('CLEAR_AUTH')
      
      // 确保storage中也被清除
      uni.removeStorageSync('token')
      uni.removeStorageSync('userInfo')
      uni.removeStorageSync('isLogin')
      
      // 验证是否成功清除
      setTimeout(() => {
        const token = uni.getStorageSync('token');
        if (token) {
          console.error('警告：清除认证信息失败，token仍存在');
          // 强制再次尝试清除
          uni.removeStorageSync('token');
        } else {
          console.log('认证信息已完全清除');
        }
      }, 100);
    },
    
    async initAuthState({ state, dispatch, commit }) {
      console.log('初始化认证状态, 当前token:', !!state.token)
      // 重新从本地存储读取token，确保最新
      const localToken = uni.getStorageSync('token')
      console.log('本地存储中的token:', !!localToken)
      
      // 如果state.token为空但本地有token，则先更新state
      if (!state.token && localToken) {
        console.log('同步token到state')
        commit('SET_TOKEN', localToken)
      }
      
      if (state.token) {
        // 如果已有 token，尝试获取用户信息
        try {
          console.log('尝试验证token...')
          await dispatch('fetchUserInfo')
          console.log('token验证成功')
          return true
        } catch (error) {
          console.log('自动登录失败，可能是token已过期:', error.message || error)
          return false
        }
      } else if (localToken) {
        // 尝试使用本地token
        try {
          console.log('使用本地token验证...')
          // 手动设置token
          commit('SET_TOKEN', localToken)
          await dispatch('fetchUserInfo')
          console.log('使用本地token验证成功')
          return true
        } catch (error) {
          console.log('使用本地token验证失败:', error.message || error)
          return false
        }
      }
      return false
    }
  },
  
  getters: {
    // 获取登录状态
    isLoggedIn(state) {
      return state.isLogin
    },
    
    // 获取用户信息
    userInfo(state) {
      return state.userInfo
    }
  }
}) 